package evaluator

import (
	"fmt"
	"monkey/ast"
	"monkey/object"
)

var (
	// NULL null实例，因为null实例是唯一，所以可以先实例化
	NULL = &object.Null{}
	// TRUE bool实例，因为bool实例只有true或false，也可以先实例化，可以共用这两个实例
	TRUE  = &object.Boolean{Value: true}
	FALSE = &object.Boolean{Value: false}
)

// Eval 求值
func Eval(node ast.Node, env *object.Environment) object.Object {
	switch node := node.(type) {
	// 求值Program
	case *ast.Program:
		return evalProgram(node, env)
	// 求值块语句
	case *ast.BlockStatement:
		return evalBlockStatement(node, env)
	// 求值表达式语句
	case *ast.ExpressionStatement:
		return Eval(node.Expression, env)
	// 求值return语句
	case *ast.ReturnStatement:
		// 求值return语句的表达式
		val := Eval(node.ReturnValue, env)
		// 是错误的话，就直接返回错误
		if isError(val) {
			return val
		}
		// 返回returnValue的实例
		return &object.ReturnValue{Value: val}

	// 求值let语句
	case *ast.LetStatement:
		// 求值let语句的=右边的表达式
		val := Eval(node.Value, env)
		if isError(val) {
			return val
		}
		// 设置环境，key是let语句的标识符，value是let语句的=右边的表达式的求值的结果
		env.Set(node.Name.Value, val)

	// 求值int值
	case *ast.IntegerLiteral:
		// 返回int类型的实例
		return &object.Integer{Value: node.Value}

	// 字符串
	case *ast.StringLiteral:
		return &object.String{Value: node.Value}

	// 求值bool值
	case *ast.Boolean:
		// bool转Boolean
		return nativeBoolToBooleanObject(node.Value)

	// 	求值前缀表达式
	case *ast.PrefixExpression:
		// 求值前缀表达式的右边的表达式
		right := Eval(node.Right, env)
		// 验证错误
		if isError(right) {
			return right
		}
		// 求值前缀表达式，使用前缀运算符和求值出来的前缀表达式的右边进行运算
		// 注意：前缀表达式的前缀运算符只有两种，第一种是-，right只支持int，第二中是!，right可以是任意类型，
		// 对于right，除了null和false，其它类型的值都是true
		return evalPrefixExpression(node.Operator, right)
	// 求值中缀表达式
	case *ast.InfixExpression:
		// 求值中缀表达式的left
		left := Eval(node.Left, env)
		// 验证错误
		if isError(left) {
			return left
		}

		// 求值中缀表达式的right
		right := Eval(node.Right, env)
		// 验证错误
		if isError(right) {
			return right
		}

		// 求值中缀表达式，使用求值得来的left和right
		return evalInfixExpression(node.Operator, left, right)
	// 求值if表达式
	case *ast.IfExpression:
		// 求值if表达式
		return evalIfExpression(node, env)

	// 求值标识符
	case *ast.Identifier:
		// 获取该标识符所绑定的值
		return evalIdentifier(node, env)
	// 求值函数定义
	// 注意：这里是函数定义，不是函数调用，所以不需要求值，只需要返回函数实例
	case *ast.FunctionLiteral:
		params := node.Parameters
		body := node.Body
		return &object.Function{Parameters: params, Body: body, Env: env}
	// 求值函数调用表达式
	case *ast.CallExpression:
		// 求值函数定义
		function := Eval(node.Function, env)
		// 验证错误
		if isError(function) {
			return function
		}

		// 求值函数调用的参数，其中的参数都是表达式，求值出这些表达式，再进行函数调用
		args := evalExpressions(node.Arguments, env)
		// 如果只有一个参数，且参数是Error，返回错误
		if len(args) == 1 && isError(args[0]) {
			return args[0]
		}
		// 调用函数求值
		// 注意：args是函数调用时的参数的切片
		return applyFunction(function, args)
	// 数组
	case *ast.ArrayLiteral:
		elements := evalExpressions(node.Elements, env)
		if len(elements) == 1 && isError(elements[0]) {
			return elements[0]
		}
		return &object.Array{Elements: elements}
	// index表达式
	case *ast.IndexExpression:
		left := Eval(node.Left, env)
		if isError(left) {
			return left
		}
		index := Eval(node.Index, env)
		if isError(index) {
			return index
		}
		return evalIndexExpression(left, index)
	case *ast.HashLiteral:
		return evalHashLiteral(node, env)
	}
	return nil
}

// 调用函数
func applyFunction(fn object.Object, args []object.Object) object.Object {
	// 验证函数
	function, ok := fn.(*object.Function)
	if !ok {
		return newError("not a function: %s", fn.Type())
	}

	// 扩展函数的环境，获取到扩展后的环境
	extendedEnv := extendFunctionEnv(function, args)
	// 求值函数体
	evaluated := Eval(function.Body, extendedEnv)
	return unwrapReturnValue(evaluated)
}

// 判断是不是return语句，是的话就返回
func unwrapReturnValue(obj object.Object) object.Object {
	if returnValue, ok := obj.(*object.ReturnValue); ok {
		return returnValue.Value
	}
	return obj
}

// 扩展函数的环境，并返回扩展后的环境
// 原先自带的环境现在被outer指向
func extendFunctionEnv(fn *object.Function, args []object.Object) *object.Environment {
	env := object.NewEnclosedEnvironment(fn.Env)

	// 设置函数调用的参数进入store
	for index, param := range fn.Parameters {
		env.Set(param.Value, args[index])
	}

	return env
}

// 求值表达式
func evalExpressions(exps []ast.Expression, env *object.Environment) []object.Object {
	var result []object.Object

	for _, e := range exps {
		// 求值单个表达式
		evaluated := Eval(e, env)
		if isError(evaluated) {
			return []object.Object{evaluated}
		}
		// 存储表达式到切片
		result = append(result, evaluated)
	}
	return result
}

// 求值标识符
func evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object {
	if val, ok := env.Get(node.Value); ok {
		return val
	}

	if builtin, ok := builtins[node.Value]; ok {
		return builtin
	}

	return newError("identifier not found: " + node.Value)
}

// 解析字符串的+
func evalStringLiteralExpression(operator string, left, right object.Object) object.Object {
	if operator != "+" {
		return newError("unknown operator: %s %s %s",
			left.Type(), operator, right.Type())
	}

	leftVal := left.(*object.String).Value
	rightVal := right.(*object.String).Value

	return &object.String{Value: leftVal + rightVal}
}

// 求值if表达式
func evalIfExpression(ie *ast.IfExpression, env *object.Environment) object.Object {
	// 求值if的条件表达式
	condition := Eval(ie.Condition, env)
	if isError(condition) {
		return condition
	}

	// 如果条件为真，执行if后面的块语句
	if isTruthy(condition) {
		return Eval(ie.Consequence, env)
		// 如果有else，执行else分支
	} else if ie.Alternative != nil {
		return Eval(ie.Alternative, env)
		// if条件表达式为假，且没有else分支，返回null
	} else {
		return NULL
	}
}

// 判断bool，除了null和false，其它的都返回true
func isTruthy(obj object.Object) bool {
	switch obj {
	case NULL:
		return false
	case TRUE:
		return true
	case FALSE:
		return false
	default:
		return true
	}
}

// 求值中缀表达式
func evalInfixExpression(operator string, left, right object.Object) object.Object {
	switch {
	// 如果中缀运算符的左边和右边都是int，求值int运算
	case left.Type() == object.INTEGER_OBJ && right.Type() == object.INTEGER_OBJ:
		return evalIntegerInfixExpression(operator, left, right)
	case left.Type() == object.STRING_OBJ && right.Type() == object.STRING_OBJ:
		return evalStringLiteralExpression(operator, left, right)
	// bool运算
	case operator == "==":
		return nativeBoolToBooleanObject(left == right)
	// bool运算
	case operator == "!=":
		return nativeBoolToBooleanObject(left != right)
	// 中缀运算符的两边的类型必须是一致的
	case left.Type() != right.Type():
		return newError("type mismatch: %s %s %s", left.Type(), operator, right.Type())
	default:
		return newError("unknown operator: %s %s %s", left.Type(), operator, right.Type())
	}
}

// 求值int类型的运算
func evalIntegerInfixExpression(operator string, left object.Object, right object.Object) object.Object {
	leftValue := left.(*object.Integer).Value
	rightValue := right.(*object.Integer).Value
	switch operator {
	case "+":
		return &object.Integer{Value: leftValue + rightValue}
	case "-":
		return &object.Integer{Value: leftValue - rightValue}
	case "*":
		return &object.Integer{Value: leftValue * rightValue}
	case "/":
		return &object.Integer{Value: leftValue / rightValue}
	case "<":
		return nativeBoolToBooleanObject(leftValue < rightValue)
	case ">":
		return nativeBoolToBooleanObject(leftValue > rightValue)
	case "==":
		return nativeBoolToBooleanObject(leftValue == rightValue)
	case "!=":
		return nativeBoolToBooleanObject(leftValue != rightValue)
	default:
		return newError("unknown operator: %s %s %s", left.Type(), operator, right.Type())
	}
}

// 求值前缀运算符
func evalPrefixExpression(operator string, right object.Object) object.Object {
	switch operator {
	case "!":
		return evalBangOperatorExpression(right)
	case "-":
		return evalMinusPrefixOperatorExpression(right)
	default:
		return newError("unknown operator: %s %s", operator, right.Type())
	}
}

// 求值-运算符
// 注意：-运算符只能用在int前面
func evalMinusPrefixOperatorExpression(right object.Object) object.Object {
	if right.Type() != object.INTEGER_OBJ {
		return newError("unknown operator: -%s", right.Type())
	}

	value := right.(*object.Integer).Value
	return &object.Integer{Value: -value}
}

// 返回一个Error实例
func newError(format string, a ...interface{}) *object.Error {
	return &object.Error{Message: fmt.Sprintf(format, a...)}
}

// 求值!，bool取反，所以，如果right是false，返回true，null返回true，其它情况下，right都是true，所以返回false
func evalBangOperatorExpression(right object.Object) object.Object {
	switch right {
	case TRUE:
		return FALSE
	case FALSE:
		return TRUE
	case NULL:
		return TRUE
	default:
		return FALSE
	}
}

// bool转Boolean
func nativeBoolToBooleanObject(input bool) object.Object {
	if input {
		return TRUE
	}
	return FALSE
}

// 求值Program
func evalProgram(program *ast.Program, env *object.Environment) object.Object {
	var result object.Object

	// Program有多条语句
	for _, statement := range program.Statements {
		// 对语句求值
		result = Eval(statement, env)

		// 判断result的类型
		switch result := result.(type) {
		// 如果result的类型是ReturnValue，则说明这条语句是return语句，需要return回去
		case *object.ReturnValue:
			return result.Value
		// 如果是result是Error类型，返回错误
		case *object.Error:
			return result
		}
	}
	return result
}

// 求值块语句
func evalBlockStatement(block *ast.BlockStatement, env *object.Environment) object.Object {
	var result object.Object

	for _, statement := range block.Statements {
		// 求值语句
		result = Eval(statement, env)

		if result != nil {
			rt := result.Type()
			// 如果是return语句或结果是错误的，就返回
			if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ {
				return result
			}
		}
	}
	return result
}

// 判断是否是Error
func isError(obj object.Object) bool {
	if obj != nil {
		return obj.Type() == object.ERROR_OBJ
	}
	return false
}

// 解析index表达式
func evalIndexExpression(left, index object.Object) object.Object {
	switch {
	// 数组的index的值必须是integer
	case left.Type() == object.ARRAY_OBJ && index.Type() == object.INTEGER_OBJ:
		return evalArrayIndexExpression(left, index)
	case left.Type() == object.HASH_OBJ:
		return evalHashIndexExpression(left, index)
	default:
		return newError("index operator not supported: %s", left.Type())
	}
}

// 解析数组的index表达式
func evalArrayIndexExpression(array, index object.Object) object.Object {
	arrayObject := array.(*object.Array)
	idx := index.(*object.Integer).Value

	// 验证索引的值
	if idx < 0 || idx > int64(len(arrayObject.Elements)-1) {
		return NULL
	}

	return arrayObject.Elements[idx]
}

func evalHashLiteral(node *ast.HashLiteral, env *object.Environment) object.Object {
	pairs := make(map[object.HashKey]object.HashPair)
	for keyNode, valueNode := range node.Pairs {
		key := Eval(keyNode, env)
		if isError(key) {
			return key
		}

		hashKey, ok := key.(object.Hashable)
		if !ok {
			return newError("unusable as hash key: %s", key.Type())
		}

		value := Eval(valueNode, env)
		if isError(value) {
			return value
		}

		hashed := hashKey.HashKey()
		pairs[hashed] = object.HashPair{Key: key, Value: value}
	}

	return &object.Hash{Pairs: pairs}
}

func evalHashIndexExpression(hash, index object.Object) object.Object {
	hashObject := hash.(*object.Hash)
	key, ok := index.(object.Hashable)
	if !ok {
		return newError("unusable as hash key: %s", index.Type())
	}

	pair, ok := hashObject.Pairs[key.HashKey()]
	if !ok {
		return NULL
	}

	return pair.Value
}
